package com.gitee.qdbp.general.common.api.reusable.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.able.jdbc.paging.PartList;
import com.gitee.qdbp.base.annotation.DataIsolation;
import com.gitee.qdbp.base.annotation.OperateTraces;
import com.gitee.qdbp.base.enums.DataState;
import com.gitee.qdbp.general.common.enums.ProcessType;

/**
 * 处理过程备注实体类
 *
 * @author zhh
 * @version 180514
 */
@OperateTraces(id = "id")
@DataIsolation("tenantCode")
public class ProcessingRecordBean implements Serializable {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 表名 **/
    public static final String TABLE = "gn_processing_record";

    /** 过程ID **/
    private String id;

    /** 租户编号 **/
    private String tenantCode;

    /** 数据类型 **/
    private String dataType;

    /** 数据ID **/
    private String dataId;

    /** 数据描述 **/
    private String dataDesc;

    /** 业务类型 **/
    private String bizType;

    /** 业务编号 **/
    private String bizCode;

    /** 可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    private Integer visibleLevel;

    /** 处理类型(0.处理|1.备注|2.结论) **/
    private ProcessType processType;

    /** 处理标题 **/
    private String processTitle;

    /** 处理描述 **/
    private String processContent;

    /** 处理状态(文字) **/
    private String processState;

    /** 处理人id **/
    private String processorId;

    /** 处理人姓名 **/
    private String processorName;

    /** 处理时间 **/
    private Date processTime;

    /** 查询字符串 **/
    private String queryString;

    /** 选项 **/
    private ProcessingRecordOptions options;

    /** 数据状态:0为正常|其他为删除 **/
    private DataState dataState;

    /** 获取过程ID **/
    public String getId() {
        return id;
    }

    /** 设置过程ID **/
    public void setId(String id) {
        this.id = id;
    }

    /** 获取租户编号 **/
    public String getTenantCode() {
        return tenantCode;
    }

    /** 设置租户编号 **/
    public void setTenantCode(String tenantCode) {
        this.tenantCode = tenantCode;
    }

    /** 获取数据类型 **/
    public String getDataType() {
        return dataType;
    }

    /** 设置数据类型 **/
    public void setDataType(String dataType) {
        this.dataType = dataType;
    }

    /** 获取数据ID **/
    public String getDataId() {
        return dataId;
    }

    /** 设置数据ID **/
    public void setDataId(String dataId) {
        this.dataId = dataId;
    }

    /** 获取数据描述 **/
    public String getDataDesc() {
        return dataDesc;
    }

    /** 设置数据描述 **/
    public void setDataDesc(String dataDesc) {
        this.dataDesc = dataDesc;
    }

    /** 获取业务类型 **/
    public String getBizType() {
        return bizType;
    }

    /** 设置业务类型 **/
    public void setBizType(String bizType) {
        this.bizType = bizType;
    }

    /** 获取业务编号 **/
    public String getBizCode() {
        return bizCode;
    }

    /** 设置业务编号 **/
    public void setBizCode(String bizCode) {
        this.bizCode = bizCode;
    }

    /** 获取可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public Integer getVisibleLevel() {
        return visibleLevel;
    }

    /** 设置可见级别:1.用户可见|2.管理员可见|3.高管可见 **/
    public void setVisibleLevel(Integer visibleLevel) {
        this.visibleLevel = visibleLevel;
    }

    /** 获取处理类型(0.处理|1.备注|2.结论) **/
    public ProcessType getProcessType() {
        return processType;
    }

    /** 设置处理类型(0.处理|1.备注|2.结论) **/
    public void setProcessType(ProcessType processType) {
        this.processType = processType;
    }

    /** 获取处理标题 **/
    public String getProcessTitle() {
        return processTitle;
    }

    /** 设置处理标题 **/
    public void setProcessTitle(String processTitle) {
        this.processTitle = processTitle;
    }

    /** 获取处理描述 **/
    public String getProcessContent() {
        return processContent;
    }

    /** 设置处理描述 **/
    public void setProcessContent(String processContent) {
        this.processContent = processContent;
    }

    /** 获取处理状态(文字) **/
    public String getProcessState() {
        return processState;
    }

    /** 设置处理状态(文字) **/
    public void setProcessState(String processState) {
        this.processState = processState;
    }

    /** 获取处理人id **/
    public String getProcessorId() {
        return processorId;
    }

    /** 设置处理人id **/
    public void setProcessorId(String processorId) {
        this.processorId = processorId;
    }

    /** 获取处理人姓名 **/
    public String getProcessorName() {
        return processorName;
    }

    /** 设置处理人姓名 **/
    public void setProcessorName(String processorName) {
        this.processorName = processorName;
    }

    /** 获取处理时间 **/
    public Date getProcessTime() {
        return processTime;
    }

    /** 设置处理时间 **/
    public void setProcessTime(Date processTime) {
        this.processTime = processTime;
    }

    /** 获取查询字符串 **/
    public String getQueryString() {
        return queryString;
    }

    /** 设置查询字符串 **/
    public void setQueryString(String queryString) {
        this.queryString = queryString;
    }

    /** 获取选项 **/
    public ProcessingRecordOptions getOptions() {
        return options;
    }

    /** 获取选项, force=是否强制返回非空对象 **/
    public ProcessingRecordOptions getOptions(boolean force) {
        if (options == null && force) {
            options = new ProcessingRecordOptions();
        }
        return options;
    }

    /** 设置选项 **/
    public void setOptions(ProcessingRecordOptions options) {
        this.options = options;
    }

    /** 获取数据状态:0为正常|其他为删除 **/
    public DataState getDataState() {
        return dataState;
    }

    /** 设置数据状态:0为正常|其他为删除 **/
    public void setDataState(DataState dataState) {
        this.dataState = dataState;
    }

    /**
     * 将当前对象转换为子类对象
     *
     * @param clazz 目标类型
     * @return 目标对象
     */
    public <T extends ProcessingRecordBean> T to(Class<T> clazz) {
        T instance;
        try {
            instance = clazz.newInstance();
        } catch (Exception e) {
            throw new IllegalArgumentException("Failed to create " + clazz.getSimpleName() + " instance.", e);
        }

        instance.setId(this.getId()); // 过程ID
        instance.setTenantCode(this.getTenantCode()); // 租户编号
        instance.setDataType(this.getDataType()); // 数据类型
        instance.setDataId(this.getDataId()); // 数据ID
        instance.setDataDesc(this.getDataDesc()); // 数据描述
        instance.setBizType(this.getBizType()); // 业务类型
        instance.setBizCode(this.getBizCode()); // 业务编号
        instance.setVisibleLevel(this.getVisibleLevel()); // 可见级别:1.用户可见|2.管理员可见|3.高管可见
        instance.setProcessType(this.getProcessType()); // 处理类型(0.处理|1.备注|2.结论)
        instance.setProcessTitle(this.getProcessTitle()); // 处理标题
        instance.setProcessContent(this.getProcessContent()); // 处理描述
        instance.setProcessState(this.getProcessState()); // 处理状态(文字)
        instance.setProcessorId(this.getProcessorId()); // 处理人id
        instance.setProcessorName(this.getProcessorName()); // 处理人姓名
        instance.setProcessTime(this.getProcessTime()); // 处理时间
        instance.setQueryString(this.getQueryString()); // 查询字符串
        instance.setOptions(this.getOptions()); // 选项
        instance.setDataState(this.getDataState()); // 数据状态:0为正常|其他为删除
        return instance;
    }

    /**
     * 将ProcessingRecordBean转换为子类对象
     *
     * @param beans 待转换的对象列表
     * @param clazz 目标类型
     * @param <T> ProcessingRecordBean或子类
     * @param <C> T的子类
     * @return 目标对象列表
     */
    public static <T extends ProcessingRecordBean, C extends T> List<C> to(List<T> beans, Class<C> clazz) {
        if (beans == null) {
            return null;
        }
        List<C> list;
        if (beans instanceof PartList) {
            PartList<C> partlist = new PartList<>();
            partlist.setTotal(((PartList<?>) beans).getTotal());
            list = partlist;
        } else {
            list = new ArrayList<>();
        }
        for (ProcessingRecordBean bean : beans) {
            list.add(bean.to(clazz));
        }
        return list;
    }

}